package org.apli.haiam.admin.jsf.managed;

import com.apli.controladores.AplinfoFactoryBean;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.List;
import java.util.ResourceBundle;
import javax.faces.application.FacesMessage;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ViewScoped;
import javax.faces.context.FacesContext;
import javax.faces.model.DataModel;
import javax.faces.model.SelectItem;
import javax.print.Doc;
import javax.print.DocFlavor;
import javax.print.DocPrintJob;
import javax.print.PrintException;
import javax.print.PrintService;
import javax.print.PrintServiceLookup;
import javax.print.SimpleDoc;
import javax.print.attribute.HashPrintRequestAttributeSet;
import javax.print.attribute.PrintRequestAttributeSet;
import org.apli.haiam.admin.entidades.UsuarioAdmin;
import org.apli.haiam.ejb.entidades.AdmDatosGlobales;
import org.apli.haiam.ejb.entidades.AdmDivisionPolitica;
import org.apli.haiam.ejb.entidades.AdmUsuario;
import org.apli.haiam.ejb.entidades.CexAgenda;
import org.apli.haiam.ejb.entidades.CexConsulta;
import org.apli.haiam.ejb.entidades.CexConsultaTerapia;
import org.apli.haiam.ejb.entidades.CexDia;
import org.apli.haiam.ejb.entidades.CexHistoriaClinica;
import org.apli.haiam.ejb.entidades.CexHorariosDia;
import org.apli.haiam.ejb.entidades.CexTipoTerapia;
import org.apli.haiam.ejb.interfaces.AdministradorHaiam;
import org.apli.haiam.ejb.interfaces.ConsExternaAdministrador;
import org.apli.jsf.managed.JsfBean;
import org.primefaces.event.RowEditEvent;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Clase backing Bean que administra la entidad CexEspecialidadMedico.
 * <p>
 * <H6>Soporte:HAIAM
 * <I>david_s_1086@hotmail.com,david.carranza@haiam.gob.ec</I></H6>
 *
 * @author david Carranza
 * @version 1.0 30/07/2014
 */
@ManagedBean
@ViewScoped
public class JsfAgendaTerapia extends JsfBean<CexConsultaTerapia> {

    final Logger log = LoggerFactory.getLogger(JsfAgendaTerapia.class);
    private CexHistoriaClinica hcPaciente;
    private String parametroBusqueda;
    private Integer busqueda;
    private UsuarioAdmin user;
    private Calendar horaInicioAm;
    private Calendar horaFinAm;
    private Calendar horaInicioPm;
    private Calendar horaFinPm;
    private Integer tipoBusqueda;
    private String apellidoPbusqueda;
    private String apellidoMbusqueda;
    private String pnombrebusqueda;
    private String snombrePbusqueda;
    private List<AdmDatosGlobales> listaDatosGlobales;
    private List<CexHistoriaClinica> listaHClinica;
    private Date fechaAgenda;
    private AdmDivisionPolitica provincia;
    private AdmDivisionPolitica canton;
    private AdmDivisionPolitica parroquia;
    private Boolean habilitar;
    public int cadulaInc = 0;
    private boolean activo;
    private boolean isextra;
    private int numeroSesiones;
    private List<AdmDatosGlobales> listaImpresorasturnos;
    private List<CexAgenda> listaHistorialTurnos;
    private ConsExternaAdministrador hcAdmin;
    private BigDecimal rangoMuinutos;
    private long diffMinutes;
    private Integer turnosManiana;
    private Integer turnsTarde;
    private boolean isGrabar;
    private int totalConsulta;
    private AdmUsuario admUsuario;
    private Date fechaFin;
    private List<CexDia> listaDia;
    private String motivoBloqueo;
    private String motivoCancelar;
    private CexTipoTerapia cexTipoTerapia;
    private List<CexTipoTerapia> listaTipoTerapia;
    private Date horaTurnoExtra;
    private List<CexConsultaTerapia> listaDiaria;
    private List<CexConsulta> listaConsulta;
    private List<CexConsultaTerapia> listaAgeTemp;
    private static final String TIPO_IMPRESORAS = "IMP_TMU220D";
    private static final String NAME_REPORTE = "RPT_TURNO.jasper";
    private static final String TIPO_REPORTE_PDF = "application/pdf";
    private static final String TIPO_REPORTE_EXC = "application/vnd.ms-excel";

    // private AdmSistema sistemaSeleccionado;
    /**
     * Constructor por defecto.
     */
    public JsfAgendaTerapia() {
        // sistemaSeleccionado = new AdmSistema();
    }

    /**
     * Inicializa los datos miembros.
     */
    @Override
    protected void inicializar() {
        //setSwGrabar(false);
        object = new CexConsultaTerapia();
        hcPaciente = new CexHistoriaClinica();
        parametroBusqueda = new String();
        busqueda = 1;
        horaInicioAm = new GregorianCalendar();
        horaFinAm = new GregorianCalendar();
        horaInicioPm = new GregorianCalendar();
        horaFinPm = new GregorianCalendar();
        tipoBusqueda = 2;
        apellidoPbusqueda = new String();
        apellidoMbusqueda = new String();
        pnombrebusqueda = new String();
        snombrePbusqueda = new String();
        listaHClinica = new ArrayList<>();
        fechaAgenda = new Date();
        provincia = new AdmDivisionPolitica();
        canton = new AdmDivisionPolitica();
        parroquia = new AdmDivisionPolitica();
        habilitar = true;
        cadulaInc = 0;
        activo = false;
        isextra = false;
        rangoMuinutos = BigDecimal.ZERO;
        diffMinutes = 0;
        turnosManiana = 0;
        turnsTarde = 0;
        isGrabar = false;
        totalConsulta = 0;
        fechaFin = new Date();
        motivoBloqueo = "";
        cexTipoTerapia = new CexTipoTerapia();
        horaTurnoExtra = new Date();
        motivoCancelar = "";
        numeroSesiones = 0;
        listaConsulta = new ArrayList<>();
        listaDiaria = new ArrayList<>();
        listaAgeTemp = new ArrayList<>();
        try {
            user = (UsuarioAdmin) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("user");
            admUsuario = user.getUser();
            listaDatosGlobales = adminObject.listar(AdmDatosGlobales.class, "estado", 1);
            listaDia = adminObject.listar(CexDia.class, "cdiEstado", 1);
            listaTipoTerapia = adminObject.listar(CexTipoTerapia.class);
            cargarImpresoraTurnos();
        } catch (Exception e) {
            log.error("inicializar() {} ", e.getMessage());
        }

    }

    /**
     * Iyección de dependencia para conectarse al EJB(Lógica de Negocio)
     * Iyección de dependencia para el sistema de Administarción. Iyección de
     * dependencia para el sistema de Emergencia.
     */
    @Override
    protected void cargarEjb() {
        //super.cargarEjb();
        String nombreMetodo = Thread.currentThread().getStackTrace()[1].getMethodName() + "()";
        if (hcAdmin == null) {
            String ejbPath = null;
            try {
                ResourceBundle property = getProperties();
                String ORBContext = property.getString("ORBContext");
                String ejbContextPath = property.getString("ejb.context.path.ConsExterna");
                ejbPath = ORBContext + ejbContextPath + "/ConsExternaAdministradorBean";
                hcAdmin = (ConsExternaAdministrador) AplinfoFactoryBean.lookupBean(ejbPath, false);
            } catch (Exception e) {
                log.error("{}: {} - {} ", new Object[]{nombreMetodo, ejbPath, e});
            }

        }

        if (adminObject == null) {
            String ejbPath = null;
            try {
                ResourceBundle property = getProperties();
                String ORBContext = property.getString("ORBContext");
                String ejbContextPath = property.getString("ejb.context.path.admin");
                ejbPath = ORBContext + ejbContextPath + "/AdministradorBeanHaiam";
                adminObject = (AdministradorHaiam) AplinfoFactoryBean.lookupBean(ejbPath, false);
            } catch (Exception e) {
                log.error("{}: {} - {} ", new Object[]{nombreMetodo, ejbPath, e});
            }
        }
    }

    /**
     * Carga en la lista las impresoras para la impresion de stickers
     */
    public void cargarImpresoraTurnos() {
        listaImpresorasturnos = new ArrayList<>();
        for (AdmDatosGlobales datosGlobales : listaDatosGlobales) {
            if (datosGlobales.getTipo().equals(TIPO_IMPRESORAS)) {
                listaImpresorasturnos.add(datosGlobales);
            }
        }
    }

    /**
     * Graba el registro asociado al objeto que se administra en la página.
     *
     * @return null, se mantiene en la página invocada.
     */
    @Override
    public String grabarAction() {
        FacesContext context = FacesContext.getCurrentInstance();
        try {
            boolean isConsulta = false;
            int numConsulta = 0;
            CexConsulta cexConsulta = new CexConsulta();

            //Verificar que este seleccionado solo una consulta para agregar las terapias
            for (CexConsulta objConsulta : listaConsulta) {
                if (objConsulta.isSeleccionar()) {
                    isConsulta = true;
                    numConsulta = numConsulta + 1;
                    cexConsulta = objConsulta;
                }

            }
            if (!isConsulta) {
                FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "No se pudo grabar", "Seleccione consulta para agendar"));
                return null;
            }
            if (numConsulta > 1) {
                FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "No se pudo grabar", "solo debe seleccionar una consulta para agendar"));
                return null;
            }

            //Verificar los permisos
            //Recupera permiso para saber si se puede agendar en la fecha seleccionada
////            List<AdmPermiso> objLicencia = (List<AdmPermiso>) adminObject.queryEJB("select p from AdmPermiso p where :var1 between p.apeFechaInicio and p.apeFechaFin and p.admMedico = :var2", fechaAgenda, object.getCexConsulta().getCexPreparacion().getCexAgenda().getCexHorariosDia().getCexHorario().getCexEspecialidadMedico().getAdmMedico());
////            if (objLicencia.size() > 0 || !objLicencia.isEmpty()) {
////                return null;
////            }
            for (CexConsultaTerapia objTerCon : listaAgeTemp) {
                if (objTerCon.getCctEstado().equals(0)) {
                    objTerCon.setCexConsulta(cexConsulta);
                    objTerCon.setCctEstado(1);
                    hcAdmin.crearTurno(objTerCon, (UsuarioAdmin) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("user"));
                } else {
                    FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "No se pudo grabar", "Seleccione turnos que no esten ocupados"));
                    return null;
                }

            }
        } catch (Exception e) {
            log.error("grabarAction() {} ", e.getMessage());

        }

        return null;
    }

    /**
     * Crea un turno extra fuera de la agenda
     *
     * @return null, se mantiene en la página invocada.
     */
    public String grabarTurnoExtra() {
//////        FacesContext context = FacesContext.getCurrentInstance();
//////        try {
//////            boolean isConsulta = false;
//////            int numConsulta = 0;
//////            CexConsulta cexConsulta = new CexConsulta();
//////
//////            //Verificar que este seleccionado solo una consulta para agregar las terapias
//////            for (CexConsulta objConsulta : listaConsulta) {
//////                if (objConsulta.isSeleccionar()) {
//////                    isConsulta = true;
//////                    numConsulta = numConsulta + 1;
//////                    cexConsulta = objConsulta;
//////                }
//////
//////            }
//////            if (!isConsulta) {
//////                FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "No se pudo grabar", "Seleccione consulta para agendar"));
//////                return null;
//////            }
//////            if (numConsulta > 1) {
//////                FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "No se pudo grabar", "solo debe seleccionar una consulta para agendar"));
//////                return null;
//////            }
//////
//////            //Verificar los permisos
//////            //Recupera permiso para saber si se puede agendar en la fecha seleccionada
//////////            List<AdmPermiso> objLicencia = (List<AdmPermiso>) adminObject.queryEJB("select p from AdmPermiso p where :var1 between p.apeFechaInicio and p.apeFechaFin and p.admMedico = :var2", fechaAgenda, object.getCexConsulta().getCexPreparacion().getCexAgenda().getCexHorariosDia().getCexHorario().getCexEspecialidadMedico().getAdmMedico());
//////////            if (objLicencia.size() > 0 || !objLicencia.isEmpty()) {
//////////                return null;
//////////            }
//////            for (CexConsultaTerapia objTerCon : listaAgeTemp) {
//////                objTerCon.setCexConsulta(cexConsulta);
//////                objTerCon.setCctEstado(1);
//////                hcAdmin.crearTurno(objTerCon, (UsuarioAdmin) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("user"));
//////
//////            }
//////        } catch (Exception e) {
//////            log.error("grabarAction() {} ", e.getMessage());
//////
//////        }

        return null;
    }

    /**
     * Metodo generico que crea un detalle de la agenda selecionada
     *
     * @param objAgenda
     * @author David Carranza
     * @param objHoraDia activado
     * @param act
     * @param actHorPri
     * @return
     */
    public HashMap<Integer, Date> asignarHoraSecuencia(CexAgenda objAgenda, CexHorariosDia objHoraDia, boolean act, boolean actHorPri) {
        FacesContext context = FacesContext.getCurrentInstance();
        HashMap<Integer, Date> mp = new HashMap<>();
        try {

            int contAgenda = 0;
            int intervaloTurno = objAgenda.getCexHorariosDia().getChdIntervalo();
            Calendar c3 = Calendar.getInstance();
            Integer secuencia = 0;
            boolean secNull = true;
            horaInicioAm = new GregorianCalendar();
            horaFinAm = new GregorianCalendar();
            horaInicioAm.setTime(objHoraDia.getChdHoraInicioAm());
            horaFinAm.setTime(objHoraDia.getChdHoraFinAm());

            //Calcular los tiempos para cada turno
            long iniAm = horaInicioAm.getTimeInMillis();
            long finAm = horaFinAm.getTimeInMillis();
            //calcular total de minitos al dia asignado al medico
            long totHoras = (finAm - iniAm);

            // calcular la diferencia en milisengundos
            //long diff = milis2 - milis1;
            // calcular la diferencia en segundos
            //long diffSeconds = diff / 1000;
            // calcular la diferencia en minutos
            diffMinutes = totHoras / (60 * 1000);

            // calcular la diferencia en horas
            //long diffHours = diff / (60 * 60 * 1000);
            // calcular la diferencia en dias
            //long diffDays = diff / (24 * 60 * 60 * 1000);
            rangoMuinutos = divisionControlada(new BigDecimal(diffMinutes), new BigDecimal(objHoraDia.getChdNumConsultas()));
            rangoMuinutos = rangoMuinutos.setScale(0, RoundingMode.HALF_UP);

            if (objAgenda.getCagSecuencia() == 0 && actHorPri) {
                c3.setTime(objHoraDia.getChdHoraInicioAm());
                secuencia = 1;

            } else {

                // si para cambiar de hora es cada un turno
                if (intervaloTurno == 1) {
                    if ((!act || act) && objAgenda.getCagEstado() == 0) {
                        c3.setTime(objHoraDia.getChdHoraInicioAm());
                        secuencia = totalConsulta;
                    } else {
                        //calcular (sumar) total de minitos al dia asignado al medico
                        c3.setTime(objAgenda.getCagHora());
                        c3.add(Calendar.MINUTE, rangoMuinutos.intValue());
                        secuencia = objAgenda.getCagSecuencia() + 1;
                    }

                } else {
//////////////////                    //calcular el rango de hora para cada turno
//////////////////                    BigDecimal rem = divisionControlada(new BigDecimal(diffMinutes), new BigDecimal(intervaloTurno));
//////////////////                    BigDecimal rango = rem.setScale(0, RoundingMode.HALF_UP);
//////////////////                    //Para cambiar de hora segun el numero de intervalo
//////////////////
//////////////////                    //Comparar si tiene otro valor quiere decir que debe estar con la misma horario del turno anterior
//////////////////                    if ((objAgenda.getAgeSecuencia() % intervaloTurno) == 0) {
//////////////////                        //calcular (sumar) total de minitos al dia asignado al medico
//////////////////                        c3.setTime(objAgenda.getAgeHora());
//////////////////                        c3.add(Calendar.MINUTE, rango.intValue());
//////////////////                        agenda.setAgeHora(c3.getTime());
//////////////////                    } else {
//////////////////                        c3.setTime(objAgenda.getAgeHora());
//////////////////                        agenda.setAgeHora(c3.getTime());
//////////////////                    }
//////////////////
//////////////////                    secuencia = objAgenda.getAgeSecuencia() + 1;
                }

                //secuencia = objAgenda.getAgeSecuencia() + 1;
                //c3.add(Calendar.MINUTE, rangoMuinutos.intValue());
            }
            if (!secNull) {
                secuencia = null;
            }
            mp.put(secuencia, c3.getTime());
        } catch (Exception e) {
            log.error("{}: {} ", "asignarHoraSecuencia", e);
        }
        return mp;
    }

    /**
     * Metodo generico que crea un detalle de la agenda selecionada
     *
     * @author David Carranza
     * @param obj
     * @param fecha
     */
    public void crearDetalle(CexTipoTerapia obj, Date fecha) {
        try {

            int contTarde = 1;
            int cont = 1;
            int contGeneral = 0;
            int totalPacientes = 0;
            CexConsultaTerapia agenda = new CexConsultaTerapia();
            Calendar horaSumada = new GregorianCalendar();
            horaSumada.setTime(obj.getCttHoraInicio());

            //Calcular la Hora Calcular los tiempos para cada turno horaInicioAm
            horaInicioAm.setTime(obj.getCttHoraInicio());
            horaFinAm.setTime(obj.getCttHoraFin());
            if (obj.getCttHoraInicioTarde() != null && obj.getCttHoraFinTarde() != null) {
                horaInicioPm.setTime(obj.getCttHoraInicioTarde());
                horaFinPm.setTime(obj.getCttHoraFinTarde());
            }

            long iniAm = horaInicioAm.getTimeInMillis();
            long finAm = horaFinAm.getTimeInMillis();
            //long iniPm = horaFinAm.getTimeInMillis();
            //long finPm = horaFinAm.getTimeInMillis();
            //calcular total de minitos al dia asignado al medico
            long totHoras = (finAm - iniAm);
            //long totHorasTarde = (finPm - iniPm);

            //calcular la diferencia en milisengundos
            //long diff = milis2 - milis1;
            //calcular la diferencia en segundos
            //long diffSeconds = diff / 1000;
            //calcular la diferencia en minutos
            diffMinutes = totHoras / (60 * 1000);

            //calcular la diferencia en horas
            //long diffHours = diff / (60 * 60 * 1000);
            //calcular la diferencia en dias
            //long diffDays = diff / (24 * 60 * 60 * 1000);
            rangoMuinutos = divisionControlada(new BigDecimal(diffMinutes), divisionControlada(new BigDecimal(obj.getCttNumeroConsultas()), new BigDecimal(obj.getCttIntervalo())));
            rangoMuinutos = rangoMuinutos.setScale(0, RoundingMode.HALF_UP);
            if (obj.getCttNumeroConsultasTarde() != null) {
                totalPacientes = obj.getCttNumeroConsultas() + obj.getCttNumeroConsultasTarde();
            } else {
                totalPacientes = obj.getCttNumeroConsultas();
            }

            //Recorrer los horarios dias para crear
            //Crear turnos de acuerdo al porcentaje de aggenda para el medico
            for (int i = 1; i <= totalPacientes; i++) {
                agenda.setCexTipoTerapia(obj);
                agenda.setCctFecha(fecha);
                agenda.setCctEstado(0);
                if (horaSumada.before(horaFinAm)) {
                    if (cont == 1) {
                        agenda.setCctHora(horaInicioAm.getTime());
                        horaSumada = horaInicioAm;
                        contGeneral++;
                    } else {
                        if (contGeneral <= obj.getCttIntervalo()) {
                            agenda.setCctHora(horaSumada.getTime());
                            contGeneral++;
                        }
                    }
                    cont++;
                    if (contGeneral == obj.getCttIntervalo()) {
                        horaSumada.add(Calendar.MINUTE, rangoMuinutos.intValue());
                        contGeneral = 0;
                    }
                } else if (obj.getCttHoraInicioTarde() != null && obj.getCttHoraFinTarde() != null) {
                    if (contTarde == 1) {
                        agenda.setCctHora(horaInicioPm.getTime());
                        horaSumada = horaInicioPm;
                        contGeneral++;
                    } else {
                        if (contGeneral <= obj.getCttIntervaloTarde()) {
                            agenda.setCctHora(horaSumada.getTime());
                            contGeneral++;
                        }
                    }
                    contTarde++;
                    if (contGeneral == obj.getCttIntervaloTarde()) {
                        horaSumada.add(Calendar.MINUTE, rangoMuinutos.intValue());
                        contGeneral = 0;
                    }
                }

                adminObject.crear(agenda, (UsuarioAdmin) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("user"));
                agenda = new CexConsultaTerapia();
            }

        } catch (Exception e) {
            log.error("{}: {} ", "crearDetalle", e);
        }
    }

    /**
     * Funcion que divide dos numero BigDecimales en el caso de que el resultado
     * sea mas extenso de lo que este puede abarcar en la expecion lo divide
     * como double
     *
     * @param A
     * @param B
     * @return BigDe
     */
    public static BigDecimal divisionControlada(BigDecimal A, BigDecimal B) {
        try {
            return A.divide(B);
        } catch (Exception e) {
            return new BigDecimal(A.doubleValue() / B.doubleValue());
        }
    }

    /**
     * Implementa el comportamiento para inicializar los datos del objeto a
     * administrar.
     *
     * @return null, retorna a la página invocada.
     */
    public String limpiarMedico() {
        cexTipoTerapia = new CexTipoTerapia();
        object = new CexConsultaTerapia();
        listaDiaria.clear();
        return null;
    }

    public String nuevaBusqueda() {
        //inicializar();
        listaHClinica = new ArrayList<>();
        return null;
    }

    /**
     * Obtiene una lista de objetos de tipo SelectedItem.
     *
     * @return la lista
     */
    @Override
    public List<SelectItem> getSelectedItem() {
//        try {
//            List<CexTurnosEnc> datos = admin.listarOrdenada(object.getClass(), "nombre", true);
//            List<SelectItem> items = new ArrayList<SelectItem>();
//            for (CexTurnosEnc obj : datos) {
//                items.add(new SelectItem(obj, obj.get));
//            }
//            return items;
//        } catch (Exception e) {
//            log.error("getSelectedItem() {} ", e.getMessage());
//        }
        return null;
    }

    public List<SelectItem> getSelectedItemTerapia() {
        String nombreMetodo = Thread.currentThread().getStackTrace()[1].getMethodName() + "()";
        try {
            List<SelectItem> items = new ArrayList<>();
            for (CexTipoTerapia obj : listaTipoTerapia) {
                items.add(new SelectItem(obj, obj.getCttNombre()));
            }
            return items;
        } catch (Exception e) {
            log.error("{}: {} ", nombreMetodo, e);
        }
        return null;
    }

    /**
     * Metodo que cancela un turno de la lista de Agenda asignado anteriormente.
     *
     * @param listaAgd
     */
    public void cancelarTurnoAgenda(List<CexAgenda> listaAgd) {
        String nombreMetodo = Thread.currentThread().getStackTrace()[1].getMethodName() + "()";
        FacesContext context = FacesContext.getCurrentInstance();

//////////        try {
//////////            String valorDocumento;
//////////            String codigoDocumento;
//////////            Integer idDocumento;
//////////            boolean isCancelar = false;
//////////            //Verifica permisp
//////////
//////////            for (Map.Entry e : user.getPermisosMap().entrySet()) {
//////////                if (e.getKey().equals("cancelarCexAgenda")) {
//////////                    isCancelar = true;
//////////                    break;
//////////                }
//////////            }
//////////            //Ingresa si posee permiso para Cancelar turno
//////////            if (isCancelar) {
//////////                //Recorrer la lista de Agenda
//////////                for (CexAgenda objecto : listaAgd) {
//////////                    //Preguntar por el seleccionado
//////////                    if (objecto.isSeleccionado()) {
//////////                        if (objecto.getCagTipo() == 0) {
//////////                            if (!objecto.getCexPreparacionList().isEmpty() || objecto.getCexPreparacionList().size() > 0) {
//////////                                FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "No se puede cancelar turno, paciente ya tiene preparación ingresada", "No se puede cancelar turno, paciente ya tiene preparación ingresada"));
//////////                            } else {
//////////                                idDocumento = objecto.getCagId();
//////////                                codigoDocumento = objecto.getCexHistoriaClinica().getChcHistoriaClinica();
//////////                                valorDocumento = Integer.toString(objecto.getCagSecuencia());
//////////                                objecto.setCexHistoriaClinica(null);
//////////                                objecto.setCagEstado(0);
//////////                                objecto.setSeleccionado(false);
//////////                                hcAdmin.cancelarTurno(objecto, (UsuarioAdmin) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("user"), idDocumento, codigoDocumento, valorDocumento);
//////////                                agenda.setCexHistoriaClinica(new CexHistoriaClinica());
//////////                                FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_INFO, "Turno cancelado satisfactoriamente", "Turno cancelado"));
//////////
//////////                            }
//////////                        } else {
//////////                            if (objecto.getCagTipo() == 2) {
//////////                                if (!objecto.getCexPreparacionList().isEmpty() || objecto.getCexPreparacionList().size() > 0) {
//////////                                    for (CexPreparacion cexPreparacionTemp : objecto.getCexPreparacionList()) {
//////////                                        if (!cexPreparacionTemp.getCexConsultaList().isEmpty() || cexPreparacionTemp.getCexConsultaList().size() > 0) {
//////////                                            FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "No se puede cancelar turno, paciente ya tiene consulta ingresada", "No se puede cancelar turno, paciente ya tiene consulta ingresada"));
//////////
//////////                                        } else {
//////////                                            FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "No se puede cancelar turno, paciente ya tiene preparación ingresada", "No se puede cancelar turno, paciente ya tiene preparación ingresada"));
//////////
//////////                                        }
//////////
//////////                                    }
//////////
//////////                                } else {
//////////                                    objecto.setSeleccionado(false);
//////////                                    adminObject.eliminar(objecto, (UsuarioAdmin) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("user"));
//////////                                    objecto.setCexHistoriaClinica(null);
//////////                                    objecto.setCagSecuencia(0);
//////////                                    objecto.setCagEstado(0);
//////////                                    objecto.setCagHora(null);
//////////
//////////                                    agenda.setCexHistoriaClinica(new CexHistoriaClinica());
//////////                                    FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_INFO, "Turno cancelado satisfactoriamente", "Turno cancelado"));
//////////                                }
//////////
//////////                            }
//////////                            for (CexHorariosDia objHorDia : listaHorarioDia) {
//////////                                objHorDia.getCexAgendaList().clear();
//////////                                objHorDia.setCexAgendaList(adminObject.listarOrdenada(CexAgenda.class, "cexHorariosDia", objHorDia, "cagFecha", fechaAgenda, "cagSecuencia", true));
//////////                            }
//////////                            return;
//////////                        }
//////////                    }
//////////
//////////                }
//////////            } else {
//////////                FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "Usuario no autorizado para cancelar turnos ", "Usuario no autorizado para cancelar turnos "));
//////////            }
//////////
//////////        } catch (Exception e) {
//////////            log.error("{}: {} ", nombreMetodo, e);
//////////        }
    }

    /**
     * Metodo que busca segun la especialidad , el Doctor y el horario que tiene
     * asignado cada doctor el turno mas cerca dispible
     *
     * @author David Carranza
     */
    public void buscarAgenda() {
        String nombreMetodo = Thread.currentThread().getStackTrace()[1].getMethodName() + "()";
        FacesContext context = FacesContext.getCurrentInstance();
        try {
            listaDiaria.clear();
            listaDiaria = admin.listarOrdenada(object.getClass(), "cctFecha", fechaAgenda, "cexTipoTerapia", cexTipoTerapia, "cctHora", true);
            if (listaDiaria.isEmpty()) {
                crearDetalle(cexTipoTerapia, fechaAgenda);
                listaDiaria = admin.listarOrdenada(object.getClass(), "cctFecha", fechaAgenda, "cexTipoTerapia", cexTipoTerapia, "cctHora", true);
            }
////            listaAgenda = admin.listarRangoOrdenada(object.getClass(), "cctFecha", fechaAgenda, fechaFin, "cexTipoTerapia", cexTipoTerapia, "cctFecha", true);
////            if (listaDiaria.isEmpty()) {
////                FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "Sin resultados encontrados", "No se encontro agenda creada en esa fecha"));
////            }
        } catch (Exception e) {
            log.error("{}: {} ", nombreMetodo, e);
        }
    }

    /**
     * Metodo que busca segun la especialidad , el Doctor y el horario que tiene
     * asignado cada doctor el turno mas cerca dispible
     *
     * @author David Carranza
     */
    public void verificarAgendamiento() {
        String nombreMetodo = Thread.currentThread().getStackTrace()[1].getMethodName() + "()";
        FacesContext context = FacesContext.getCurrentInstance();
        int contGen = 1;
        boolean isWhile = true;
        Calendar cal;
        boolean isDiaValido;
        boolean isSelect;
        Date fechaSumada = fechaAgenda;
        CexConsultaTerapia cexAgenda = new CexConsultaTerapia();
        List<CexConsultaTerapia> listaAgendaTemp = new ArrayList<>();
        listaAgeTemp = new ArrayList<>();
        try {

            //Verificar Turnos seleccionados
            int selectMult = 0;
            boolean isTurnoLibre = false;
            //Verificar si existen turnos libre o si estan seleccionados mas de 1 turnos
            for (CexConsultaTerapia objAgenda : listaDiaria) {
                if (objAgenda.isAsignada()) {
                    selectMult = selectMult + 1;
                    cexAgenda = objAgenda;
                    listaAgeTemp.add(cexAgenda);
                }
                if (objAgenda.getCctEstado() == 0) {
                    isTurnoLibre = true;
                }

            }

            if (selectMult > 1) {
                FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "Se ha seleccionado mas de un turno", "Solo es permitido seleccionar un turno para agendar"));
                listaAgeTemp.clear();
                return;
            } else if (selectMult == 0) {
                FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "No ha seleccionado turno", "Seleccionar al menos un turno para agendar"));
                return;
            }

            if (!isTurnoLibre) {
                FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "Agenda no disponible", "No dispone de turnos libres para esta agenda"));
                return;
            }

            if (cexAgenda.getCctEstado() > 0) {
                FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "Turno no disponible", "Seleccione un turno que no ste agendado"));
                return;
            }

            //Recupera permiso para saber si se puede agendar en la fecha seleccionada
////            List<AdmPermiso> objLicencia = (List<AdmPermiso>) adminObject.queryEJB("select p from AdmPermiso p where :var1 between p.apeFechaInicio and p.apeFechaFin and p.admMedico = :var2", fechaSumada, object.getCexConsulta().getCexPreparacion().getCexAgenda().getCexHorariosDia().getCexHorario().getCexEspecialidadMedico().getAdmMedico());
////            if (objLicencia.size() > 0 || !objLicencia.isEmpty()) {
////                return;
////            }
            //List<CexPermiso> objLicencia = adminObject.ejecutarQueryNativoLista("SELECT * FROM cex_Permiso where med_id = " + object.getCexHorario().getCexEspecialidadMedico().getCexMedico().getMedId() + " and date('" + fecha + "') between per_fecha_inicio and per_fecha_fin;", CexPermiso.class);
            while (isWhile) {
                //sumar un dia a la fecha actual hasta que encuentre dia disponible
                cal = new GregorianCalendar();
                cal.setTime(fechaSumada);
                cal.add(Calendar.DATE, 1);
                fechaSumada = cal.getTime();
                Integer diatEMP = cal.get(Calendar.DAY_OF_WEEK);
                isDiaValido = false;
                isSelect = false;
                listaAgendaTemp.clear();

                //Validar para el while
                //Recupera permiso para saber si se puede agendar en la fecha seleccionada
////                List<AdmPermiso> objLicenciaSum = (List<AdmPermiso>) adminObject.queryEJB("select p from AdmPermiso p where :var1 between p.apeFechaInicio and p.apeFechaFin and p.admMedico = :var2", fechaSumada, object.getCexConsulta().getCexPreparacion().getCexAgenda().getCexHorariosDia().getCexHorario().getCexEspecialidadMedico().getAdmMedico());
////                if (objLicenciaSum.size() > 0 || !objLicenciaSum.isEmpty()) {
////                    continue;
////                }
                //recorre la lista de dias para trabajar solo con los dias seleccionados
                for (CexDia objDia : listaDia) {
                    if (objDia.isAsignada()) {
                        isSelect = true;
                        if (diatEMP.equals(objDia.getCdiId())) {
                            isDiaValido = true;
                            contGen++;
                            break;
                        }
                    }
                }

                if (!isSelect) {
                    FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "No ha seleccionado dia", "Seleccionar al menos un dia para agendar"));
                    listaAgeTemp.clear();
                    return;
                }

                if (contGen == numeroSesiones) {
                    isWhile = false;
                }

                //Validar si el dia estuvo seleccionado
                if (!isDiaValido) {
                    continue;
                }

                //Preguntar si tiene agenda ese dia
                listaAgendaTemp = admin.listar(CexConsultaTerapia.class, "cctFecha", fechaSumada, "cexTipoTerapia", cexTipoTerapia);

                //Verfifica que existea agenda de ese horario
                if (listaAgendaTemp.isEmpty() || listaAgendaTemp.size() <= 0) {
                    if ((cexTipoTerapia.getCttHoraInicio() != null && cexTipoTerapia.getCttHoraFin() != null) || (cexTipoTerapia.getCttHoraInicioTarde() != null && cexTipoTerapia.getCttHoraFinTarde() != null)) {
                        listaAgendaTemp = crearDetalleLista(fechaSumada, cexTipoTerapia);
                    }

                    //Verificar si existen turnos libre o si estan seleccionados mas de 1 turnos
                    for (CexConsultaTerapia objAgendas : listaAgendaTemp) {
                        if (cexAgenda.getCctHora().equals(objAgendas.getCctHora()) && objAgendas.getCctEstado() == 0) {
                            listaAgeTemp.add(objAgendas);
                            break;
                        }
                    }
                } else {
                    //Verificar si hay turnos libres en caso de no haber turnos libres crear agenda siguiente
                    // Comprobar si el numero de turnos es mayor o igual al numero asignado en los horarios del medico
                    // esto mas en el caso de los turnos migrados

                    for (CexConsultaTerapia cexAgetemp1 : listaAgendaTemp) {
                        if (cexAgenda.getCctHora().equals(cexAgetemp1.getCctHora()) && cexAgetemp1.getCctEstado() == 0) {
                            listaAgeTemp.add(cexAgetemp1);
                            break;
                        }
                    }
                }

            }

        } catch (Exception e) {
            log.error("{}: {} ", nombreMetodo, e);
        }
    }

    /**
     * Metodo generico que crea un agenda de la agenda selecionada
     *
     * @param fechaSumada
     * @param obj
     * @author David Carranza
     * @return
     */
    public List<CexConsultaTerapia> crearDetalleLista(Date fechaSumada, CexTipoTerapia obj) {
        List<CexConsultaTerapia> listTemp = new ArrayList<>();
        try {

            int contTarde = 1;
            int cont = 1;
            int contGeneral = 0;
            int totalPacientes = 0;

            CexConsultaTerapia agenda = new CexConsultaTerapia();
            Calendar horaSumada = new GregorianCalendar();
            horaSumada.setTime(obj.getCttHoraInicio());

            //Calcular la Hora Calcular los tiempos para cada turno horaInicioAm
            horaInicioAm.setTime(obj.getCttHoraInicio());
            horaFinAm.setTime(obj.getCttHoraFin());
            if (obj.getCttHoraInicioTarde() != null && obj.getCttHoraFinTarde() != null) {
                horaInicioPm.setTime(obj.getCttHoraInicioTarde());
                horaFinPm.setTime(obj.getCttHoraFinTarde());
            }

            long iniAm = horaInicioAm.getTimeInMillis();
            long finAm = horaFinAm.getTimeInMillis();
            //long iniPm = horaFinAm.getTimeInMillis();
            //long finPm = horaFinAm.getTimeInMillis();
            //calcular total de minitos al dia asignado al medico
            long totHoras = (finAm - iniAm);
            //long totHorasTarde = (finPm - iniPm);

            //calcular la diferencia en milisengundos
            //long diff = milis2 - milis1;
            //calcular la diferencia en segundos
            //long diffSeconds = diff / 1000;
            //calcular la diferencia en minutos
            diffMinutes = totHoras / (60 * 1000);

            //calcular la diferencia en horas
            //long diffHours = diff / (60 * 60 * 1000);
            //calcular la diferencia en dias
            //long diffDays = diff / (24 * 60 * 60 * 1000);
            rangoMuinutos = divisionControlada(new BigDecimal(diffMinutes), divisionControlada(new BigDecimal(obj.getCttNumeroConsultas()), new BigDecimal(obj.getCttIntervalo())));
            rangoMuinutos = rangoMuinutos.setScale(0, RoundingMode.HALF_UP);
            if (obj.getCttNumeroConsultasTarde() != null) {
                totalPacientes = obj.getCttNumeroConsultas() + obj.getCttNumeroConsultasTarde();
            } else {
                totalPacientes = obj.getCttNumeroConsultas();
            }

            //Recorrer los horarios dias para crear
            //Crear turnos de acuerdo al porcentaje de aggenda para el medico
            for (int i = 1; i <= totalPacientes; i++) {
                agenda.setCexTipoTerapia(obj);
                agenda.setCctEstado(0);
                agenda.setCctFecha(fechaSumada);
                if (horaSumada.before(horaFinAm)) {
                    if (cont == 1) {
                        agenda.setCctHora(horaInicioAm.getTime());
                        horaSumada = horaInicioAm;
                        contGeneral++;
                    } else {
                        if (contGeneral <= obj.getCttIntervalo()) {
                            agenda.setCctHora(horaSumada.getTime());
                            contGeneral++;
                        }
                    }
                    cont++;
                    if (contGeneral == obj.getCttIntervalo()) {
                        horaSumada.add(Calendar.MINUTE, rangoMuinutos.intValue());
                        contGeneral = 0;
                    }
                } else if (obj.getCttHoraInicioTarde() != null && obj.getCttHoraFinTarde() != null) {
                    if (contTarde == 1) {
                        agenda.setCctHora(horaInicioPm.getTime());
                        horaSumada = horaInicioPm;
                        contGeneral++;
                    } else {
                        if (contGeneral <= obj.getCttIntervaloTarde()) {
                            agenda.setCctHora(horaSumada.getTime());
                            contGeneral++;
                        }
                    }
                    contTarde++;
                    if (contGeneral == obj.getCttIntervaloTarde()) {
                        horaSumada.add(Calendar.MINUTE, rangoMuinutos.intValue());
                        contGeneral = 0;
                    }
                }

                adminObject.crear(agenda, (UsuarioAdmin) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("user"));
                listTemp.add(agenda);
                agenda = new CexConsultaTerapia();
            }

        } catch (Exception e) {
            log.error("{}: {} ", "crearDetalle", e);
        }
        return listTemp;
    }

    public void onRowEdit(RowEditEvent event) {
        String nombreMetodo = Thread.currentThread().getStackTrace()[1].getMethodName() + "()";
        try {
            CexAgenda objAgen = (CexAgenda) event.getObject();
            adminObject.modificar(objAgen, (UsuarioAdmin) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("user"));
        } catch (Exception e) {
            log.error("{}: {} ", nombreMetodo, e);
        }
    }

    public void onRowCancel(RowEditEvent event) {
        FacesMessage msg = new FacesMessage("Edit Cancelled", ((CexAgenda) event.getObject()).getCagObservacion());
        FacesContext.getCurrentInstance().addMessage(null, msg);
    }

    /**
     * Metodo verifica si existen turnos disponibles para la ventanilla cuando
     * sea de tipo 1
     *
     * @author David Carranza
     */
    public void bloquearTurno() {
        String nombreMetodo = Thread.currentThread().getStackTrace()[1].getMethodName() + "()";
        FacesContext context = FacesContext.getCurrentInstance();
        try {
            boolean isGraba = false;
//////////            for (CexAgenda cexAge : listaAgenda) {
//////////                if (cexAge.getCagEstado() == 0 && cexAge.isSeleccionado()) {
//////////                    cexAge.setCagEstado(4);
//////////                    cexAge.setCagObservacion(motivoBloqueo.toUpperCase());
//////////                    adminObject.modificar(cexAge, (UsuarioAdmin) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("user"));
//////////                    isGraba = true;
//////////                }
//////////            }
            if (isGraba) {
                FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_INFO, "Agenda Bloqueada", "Se bloqueo correctamente la agenda cierrre la ventana emergente"));
            }
        } catch (Exception e) {
            log.error("{}: {} ", nombreMetodo, e);
        }
    }

    /**
     * Metodo que agregar una observacion a la cancelaciond e turno
     *
     * @author David Carranza
     */
    public void cancelarTurno() {
//////////        String nombreMetodo = Thread.currentThread().getStackTrace()[1].getMethodName() + "()";
//////////        FacesContext context = FacesContext.getCurrentInstance();
//////////        try {
//////////            String valorDocumento;
//////////            String codigoDocumento;
//////////            Integer idDocumento;
//////////            boolean isCancelar = false;
//////////            //Verifica permisp
//////////
//////////            for (Map.Entry e : user.getPermisosMap().entrySet()) {
//////////                if (e.getKey().equals("cancelarCexAgenda")) {
//////////                    isCancelar = true;
//////////                    break;
//////////                }
//////////            }
//////////            //Ingresa si posee permiso para Cancelar turno
//////////            if (isCancelar) {
//////////                //Recorrer la lista de turnos a eliminar
//////////                for (CexAgenda objecto : listaAgenda) {
//////////                    //Preguntar por el seleccionado
//////////                    if (objecto.isSeleccionado()) {
//////////                        if (objecto.getCagTipo() == 0) {
//////////                            if (!objecto.getCexPreparacionList().isEmpty() || objecto.getCexPreparacionList().size() > 0) {
//////////                                FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "No se puede cancelar turno, paciente ya tiene preparación ingresada", "No se puede cancelar turno, paciente ya tiene preparación ingresada"));
//////////                            } else {
//////////                                idDocumento = objecto.getCagId();
//////////                                codigoDocumento = objecto.getCexHistoriaClinica().getChcHistoriaClinica();
//////////                                valorDocumento = Integer.toString(objecto.getCagSecuencia());
//////////                                objecto.setCexHistoriaClinica(null);
//////////                                objecto.setCagObservacion(motivoCancelar);
//////////                                objecto.setCagEstado(0);
//////////                                objecto.setSeleccionado(false);
//////////                                hcAdmin.cancelarTurno(objecto, (UsuarioAdmin) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("user"), idDocumento, codigoDocumento, valorDocumento);
//////////                                agenda.setCexHistoriaClinica(new CexHistoriaClinica());
//////////                                FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_INFO, "Turno cancelado satisfactoriamente", "Turno cancelado"));
//////////
//////////                            }
//////////                        } else {
//////////                            if (objecto.getCagTipo() == 2) {
//////////                                if (!objecto.getCexPreparacionList().isEmpty() || objecto.getCexPreparacionList().size() > 0) {
//////////                                    for (CexPreparacion cexPreparacionTemp : objecto.getCexPreparacionList()) {
//////////                                        if (!cexPreparacionTemp.getCexConsultaList().isEmpty() || cexPreparacionTemp.getCexConsultaList().size() > 0) {
//////////                                            FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "No se puede cancelar turno, paciente ya tiene consulta ingresada", "No se puede cancelar turno, paciente ya tiene consulta ingresada"));
//////////
//////////                                        } else {
//////////                                            FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "No se puede cancelar turno, paciente ya tiene preparación ingresada", "No se puede cancelar turno, paciente ya tiene preparación ingresada"));
//////////
//////////                                        }
//////////
//////////                                    }
//////////
//////////                                } else {
//////////                                    objecto.setSeleccionado(false);
//////////                                    adminObject.eliminar(objecto, (UsuarioAdmin) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("user"));
//////////                                    objecto.setCexHistoriaClinica(null);
//////////                                    objecto.setCagSecuencia(0);
//////////                                    objecto.setCagEstado(0);
//////////                                    objecto.setCagHora(null);
//////////
//////////                                    agenda.setCexHistoriaClinica(new CexHistoriaClinica());
//////////                                    FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_INFO, "Turno cancelado satisfactoriamente", "Turno cancelado"));
//////////                                }
//////////
//////////                            }
//////////                            for (CexHorariosDia objHorDia : listaHorarioDia) {
//////////                                objHorDia.getCexAgendaList().clear();
//////////                                objHorDia.setCexAgendaList(adminObject.listarOrdenada(CexAgenda.class, "cexHorariosDia", objHorDia, "cagFecha", fechaAgenda, "cagSecuencia", true));
//////////                            }
//////////                        }
//////////                    }
//////////                }
//////////                object = new CexEspecialidadMedico();
//////////            } else {
//////////                FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "formDatos").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "Usuario no autorizado para cancelar turnos ", "Usuario no autorizado para cancelar turnos "));
//////////            }
//////////        } catch (Exception e) {
//////////            log.error("{}: {} ", nombreMetodo, e);
//////////        }
    }

    /**
     * Metodo que busca una historia clinica
     *
     *
     * @author David Carranza
     */
    public void buscarHc() {
        String nombreMetodo = Thread.currentThread().getStackTrace()[1].getMethodName() + "()";
        FacesContext context = FacesContext.getCurrentInstance();
        try {
            parametroBusqueda = parametroBusqueda.trim();
            listaConsulta.clear();
            if (parametroBusqueda.equals("")) {
                FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "valorBusqueda").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "Valor nullo no permitido", "Ingrese parametro de busqueda"));

            } else {
                if (tipoBusqueda == 1) {
                    listaConsulta = admin.listar(CexConsulta.class, "ccoFecha", fechaFin, "cexPreparacion.cexAgenda.cexHistoriaClinica.chcHistoriaClinica", parametroBusqueda, "ccoEstado", 1);
                    if (listaConsulta.isEmpty()) {

                        FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "valorBusqueda").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "Busqueda sin resultados", "No se encontro paciente"));
                    }
                    parametroBusqueda = "";
                }

                if (tipoBusqueda == 2) {
                    listaConsulta = admin.listar(CexConsulta.class, "ccoFecha", fechaFin, "cexPreparacion.cexAgenda.cexHistoriaClinica.chcCedula", parametroBusqueda, "ccoEstado", 1);
                    if (listaConsulta.isEmpty()) {

                        FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "valorBusqueda").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "Busqueda sin resultados", "No se encontro paciente"));
                    }
                    parametroBusqueda = "";
                } else if (tipoBusqueda == 3) {
                    listaConsulta = admin.listar(CexConsulta.class, "ccoFecha", fechaFin, "cexPreparacion.cexAgenda.cexHistoriaClinica.chcPasaporte", parametroBusqueda, "ccoEstado", 1);
                    if (listaConsulta.isEmpty()) {
                        FacesContext.getCurrentInstance().addMessage(findComponent(context.getViewRoot(), "valorBusqueda").getClientId(), new FacesMessage(FacesMessage.SEVERITY_ERROR, "Busqueda sin resultados", "No se encontro paciente"));
                    }
                    parametroBusqueda = "";
                }
            }
        } catch (Exception e) {
            log.error("{}: {} ", nombreMetodo, e);
        }
    }

    /**
     * Metodo que busca una historia clinica por apellidos
     *
     *
     *
     *
     * @author David Carranza
     */
    public void buscarApellidos() {
        String nombreMetodo = Thread.currentThread().getStackTrace()[1].getMethodName() + "()";
        FacesContext context = FacesContext.getCurrentInstance();
        if (admin == null) {
            listaHClinica = null;
            return;
        }
        try {
            listaHClinica.clear();
            apellidoPbusqueda = apellidoPbusqueda.toUpperCase().trim();
            apellidoMbusqueda = apellidoMbusqueda.toUpperCase().trim();
            pnombrebusqueda = pnombrebusqueda.toUpperCase().trim();
            snombrePbusqueda = snombrePbusqueda.toUpperCase().trim();
            listaHClinica = (List<CexHistoriaClinica>) admin.queryEJB("select a from CexHistoriaClinica a where a.chcApellidoPaterno like :var1 and a.chcApellidoMaterno like :var2 and a.chcPrimerNombre like :var3 and a.chcSegundoNombre like :var4 and a.chcEstado = 1", "%" + apellidoPbusqueda + "%", "%" + apellidoMbusqueda + "%", "%" + pnombrebusqueda + "%", "%" + snombrePbusqueda + "%");
            //listaHClinica = admin.ejecutarQueryNativoLista("SELECT * from cex_historia_clinica WHERE hc_apellido_paterno LIKE '%" + apellidoPbusqueda + "%' and hc_apellido_materno like '%" + apellidoMbusqueda + "%' and hc_primer_nombre like '%" + pnombrebusqueda + "%' and hc_segundo_nombre like '%" + snombrePbusqueda + "%' and hc_estado = 1 ; ", CexHistoriaClinica.class);
            if (listaHClinica.isEmpty() || listaHClinica.size() <= 0) {
                listaHClinica.clear();
            }
        } catch (Exception e) {
            log.error("{}: {} ", nombreMetodo, e);
        }

    }

    /*
     * Metodo que imprime directamente en una impresra byte
     */
    public void print(CexAgenda turno) throws IOException {
        //FileInputStream inputStream = null;
        InputStream tex = null;
        SimpleDateFormat sf = new SimpleDateFormat("dd/MM/yyyy");
        String fecha = sf.format(turno.getCagFecha());
        SimpleDateFormat sfHora = new SimpleDateFormat("HH:mm");
        String hora = "";
        if (turno.getCagHora() != null) {
            hora = sfHora.format(turno.getCagHora());
        }
        String impresora = "SIN IMPRESORA";
        PrintService impresora11 = null;

        try {
            //inputStream = new FileInputStream("e:/archivo.txt");

            String cadena = "************************************* \n\n"
                    + "RESPONSABLE: " + turno.getCagNombreUsuario() + " \n"
                    + "FECHA: " + fecha + " \n"
                    + turno.getCagNombreInstitucion() + "\n"
                    + turno.getCexHorariosDia().getCexHorario().getCexEspecialidadMedico().getCexEspecialidad().getCesNombre() + "\n"
                    + "NÚMERO CARPETA: " + turno.getCexHistoriaClinica().getChcHistoriaClinica() + "\n"
                    + "CÉDULA: " + turno.getCexHistoriaClinica().getChcCedula() + "\n"
                    + "TURNO: " + turno.getCagSecuencia() + "\t HORA: " + hora + " \n"
                    + "MEDICO: " + turno.getCexHorariosDia().getCexHorario().getCexEspecialidadMedico().getAdmMedico().getAmeNombreFull() + "\n"
                    + "PACIENTE: " + turno.getCexHistoriaClinica().getChcNombreFull() + "\n"
                    + "***************************************\n"
                    + "\n"
                    + "\n"
                    + "SE RECOMIENDA ESTAR 30 MIN ANTES\n"
                    + " DE LA HORA ESPECIFICADA\n"
                    + "\n";
            String te2 = converteCaracter(cadena);
            tex = new ByteArrayInputStream(te2.getBytes("UTF-8"));

        } catch (UnsupportedEncodingException e) {
            log.error("printExtra() {} ", e.getMessage());
        }
        if (tex == null) {
            return;
        }

        DocFlavor docFormat = DocFlavor.INPUT_STREAM.AUTOSENSE;
        Doc document = new SimpleDoc(tex, docFormat, null);

        PrintRequestAttributeSet attributeSet = new HashPrintRequestAttributeSet();

        for (AdmDatosGlobales datoGlobal : listaImpresorasturnos) {
            if (user.getIp().equals(datoGlobal.getClave())) {
                impresora = datoGlobal.getValor();
                break;
            }
        }
        ////       impresora11 = PrintServiceLookup.lookupDefaultPrintService();
        PrintService[] printService = PrintServiceLookup.lookupPrintServices(null, null);
        for (PrintService printService1 : printService) {
            if (printService1.getName().equals(impresora)) {
                impresora11 = printService1;
            }
        }

        if (impresora11 != null) {
            DocPrintJob printJob = impresora11.createPrintJob();
            try {

                printJob.print(document, attributeSet);
            } catch (PrintException e) {
                log.error("printExtra() {} ", e.getMessage());
            }
        } else {
            log.error("No existen impresoras instaladas");
            for (PrintService printService1 : printService) {
                log.error(printService1.getName());
            }

        }

        tex.close();
    }

    /*
     * Metodo que imprime una lista de turnos directamente en una impresra byte
     */
    public void printLista(List<CexHorariosDia> listaTurno) throws IOException {
        //FileInputStream inputStream = null;
        InputStream tex = null;
        SimpleDateFormat sf = new SimpleDateFormat("dd/MM/yyyy");
        String fecha;
        SimpleDateFormat sfHora = new SimpleDateFormat("HH:mm");
        String hora = "";
        String te2;
        DocFlavor docFormat;
        Doc document;
        DocPrintJob printJob;
        PrintService impresora11 = null;
        String impresora = "SIN IMPRESORA";
        for (CexHorariosDia horD : listaTurno) {
            for (CexAgenda turno : horD.getCexAgendaList()) {
                if (turno.isSeleccionado()) {

                    fecha = sf.format(turno.getCagFecha());
                    try {

                        if (turno.getCagHora() != null) {
                            hora = sfHora.format(turno.getCagHora());
                        }

                        //inputStream = new FileInputStream("e:/archivo.txt");
                        String cadena = "************************************* \n\n"
                                + "RESPONSABLE: " + turno.getCagNombreUsuario() + " \n"
                                + "FECHA: " + fecha + " \n"
                                + turno.getCagNombreInstitucion() + "\n"
                                + turno.getCexHorariosDia().getCexHorario().getCexEspecialidadMedico().getCexEspecialidad().getCesNombre() + "\n"
                                + "NÚMERO CARPETA: " + turno.getCexHistoriaClinica().getChcHistoriaClinica() + "\n"
                                + "CÉDULA: " + turno.getCexHistoriaClinica().getChcCedula() + "\n"
                                + "TURNO: " + turno.getCagSecuencia() + "\t HORA: " + hora + " \n"
                                + "MEDICO: " + turno.getCexHorariosDia().getCexHorario().getCexEspecialidadMedico().getAdmMedico().getAmeNombreFull() + "\n"
                                + "PACIENTE: " + turno.getCexHistoriaClinica().getChcNombreFull() + "\n"
                                + "***************************************\n"
                                + "\n"
                                + "\n"
                                + "SE RECOMIENDA ESTAR 30 MIN ANTES\n"
                                + " DE LA HORA ESPECIFICADA\n"
                                + "\n";
                        te2 = converteCaracter(cadena);
                        tex = new ByteArrayInputStream(te2.getBytes("UTF-8"));

                    } catch (UnsupportedEncodingException e) {
                        log.error("printExtra() {} ", e.getMessage());
                    }
                    if (tex == null) {
                        return;
                    }

                    docFormat = DocFlavor.INPUT_STREAM.AUTOSENSE;
                    document = new SimpleDoc(tex, docFormat, null);

                    PrintRequestAttributeSet attributeSet = new HashPrintRequestAttributeSet();

                    for (AdmDatosGlobales datoGlobal : listaImpresorasturnos) {
                        if (user.getIp().equals(datoGlobal.getClave())) {
                            impresora = datoGlobal.getValor();
                            break;
                        }
                    }
                    //   impresora11 = PrintServiceLookup.lookupDefaultPrintService();
                    PrintService[] printService = PrintServiceLookup.lookupPrintServices(null, null);
                    for (PrintService printService1 : printService) {
                        if (printService1.getName().equals(impresora)) {
                            impresora11 = printService1;
                        }
                    }

                    if (impresora11 != null) {
                        printJob = impresora11.createPrintJob();
                        try {

                            printJob.print(document, attributeSet);
                        } catch (PrintException e) {
                            log.error("printExtra() {} ", e.getMessage());
                        }
                    } else {
                        log.error("No existen impresoras instaladas");
                        for (PrintService printService1 : printService) {
                            log.error(printService1.getName());
                        }

                    }

                    tex.close();
                }
            }
        }
    }

    private static String converteCaracter(String linha) throws IOException {
        String texto = "";

        //Ç     128    ×       158   +       188     +       218    °       248  
        //ü     129    ?       159   ¢       189     _       219    ¨       249  
        //é     130    á       160   ¥       190     _       220    ·       250  
        //â     131    í       161   +       191     ¦       221    ¹       251  
        //ä     132    ó       162   +       192     Ì       222    ³       252  
        //à     133    ú       163   -       193     _       223    ²       253  
        //å     134    ñ       164   -       194     Ó       224    _       254  
        //ç     135    Ñ       165   +       195     ß       225            255  
        //ê     136    ª       166   -       196     Ô       226  
        //ë     137    º       167   +       197     Ò       227  
        //è     138    ¿       168   ã       198     õ       228  
        //ï     139    ®       169   Ã       199     Õ       229  
        //î     140    ¬       170   +       200     µ       230  
        //ì     141    ½       171   +       201     Þ       231  
        //Ä     142    ¼       172   -       202     Þ       232  
        //Å     143    ¡       173   -       203     Ú       233  
        //É     144    «       174   ¦       204     Û       234  
        //æ       145    »       175   -       205     Ù       235  
        //Æ       146    _       176   +       206     ý       236  
        //ô       147    _       177   ¤       207     Ý       237  
        //ö       148    _       178   ð       208     ¯       238  
        //ò       149    ¦       179   Ð       209     ´       239  
        //û       150    ¦       180   Ê       210     ­       240  
        //ù       151    Á       181   Ë       211     ±       241  
        //ÿ       152    Â       182   È       212     _       242  
        //Ö       153    À       183   i       213     ¾       243  
        //Ü       154    ©       184   Í       214     ¶       244  
        //ø       155    ¦       185   Î       215     §       245  
        //£       156    ¦       186   Ï       216     ÷       246  
        //Ø       157    +       187   +       217     ¸       247}  
        for (Character c : linha.toCharArray()) {
            switch (c) {
                case 'á':
                    c = 'a';
                    break;
                case 'é':
                    c = 'e';
                    break;
                case 'í':
                    c = 'i';
                    break;
                case 'ó':
                    c = 'o';
                    break;
                case 'ú':
                    c = 'u';
                    break;
                case 'Á':
                    c = 'A';
                    break;
                case 'É':
                    c = 'E';
                    break;
                case 'Í':
                    c = 'I';
                    break;
                case 'Ó':
                    c = 'O';
                    break;
                case 'Ú':
                    c = 'U';
                    break;
                case 'ñ':
                    c = 'n';
                    break;
                case 'Ñ':
                    c = 'N';
                    break;
            }
            texto = (texto + c);
        }
        return texto;
    }

    /*
     * Metodo que imprime directamente en una impresra byte
     */
    public void printExtra(CexAgenda turno) throws IOException {
        //FileInputStream inputStream = null;
        InputStream tex = null;
        SimpleDateFormat sf = new SimpleDateFormat("dd/MM/yyyy");
        String fecha = sf.format(turno.getCagFecha());
        SimpleDateFormat sfHora = new SimpleDateFormat("HH:mm");
        String hora = "";
        String te2;
        if (turno.getCagHora() != null) {
            hora = sfHora.format(turno.getCagHora());
        }
        String impresora = "SIN IMPRESORA";
        PrintService impresora11 = null;
        try {
            //inputStream = new FileInputStream("e:/archivo.txt");

            String cadena = "************************************* \n\n"
                    + "RESPONSABLE: " + turno.getCagNombreUsuario() + " \n"
                    + "FECHA: " + fecha + " \n"
                    + turno.getCagNombreInstitucion() + "\n"
                    + turno.getCexHorariosDia().getCexHorario().getCexEspecialidadMedico().getCexEspecialidad().getCesNombre() + "\n"
                    + "HISTORIA CLINICA: " + turno.getCexHistoriaClinica().getChcHistoriaClinica() + "\n"
                    + "TURNO: " + turno.getCagSecuencia() + "\t HORA: " + hora + " \n"
                    + "MEDICO: " + turno.getCexHorariosDia().getCexHorario().getCexEspecialidadMedico().getAdmMedico().getAmeNombreFull() + "\n"
                    + "PACIENTE: " + turno.getCexHistoriaClinica().getChcNombreFull() + "\n"
                    + "*******   TURNO        EXTRA    ********\n"
                    + "\n"
                    + "\n"
                    + "SE RECOMIENDA ESTAR 30 MIN ANTES\n"
                    + " DE LA HORA ESPECIFICADA\n"
                    + "\n";
            te2 = converteCaracter(cadena);
            tex = new ByteArrayInputStream(te2.getBytes("UTF-8"));

        } catch (UnsupportedEncodingException e) {
            log.error("printExtra() {} ", e.getMessage());
        }
        if (tex == null) {
            return;
        }

        DocFlavor docFormat = DocFlavor.INPUT_STREAM.AUTOSENSE;
        Doc document = new SimpleDoc(tex, docFormat, null);

        PrintRequestAttributeSet attributeSet = new HashPrintRequestAttributeSet();

        for (AdmDatosGlobales datoGlobal : listaImpresorasturnos) {
            if (user.getIp().equals(datoGlobal.getClave())) {
                impresora = datoGlobal.getValor();
                break;
            }
        }
        // PrintService impresora11 = PrintServiceLookup.lookupDefaultPrintService();
        PrintService[] printService = PrintServiceLookup.lookupPrintServices(null, null);
        for (PrintService printService1 : printService) {
            if (printService1.getName().equals(impresora)) {
                impresora11 = printService1;
            }
        }

        if (impresora11 != null) {
            DocPrintJob printJob = impresora11.createPrintJob();
            try {
                printJob.print(document, attributeSet);
            } catch (PrintException e) {
                log.error("printExtra() {} ", e.getMessage());
            }
        } else {
            log.error("No existen impresoras instaladas");
        }

        tex.close();
    }

    public List<SelectItem> getSelectedItemProvincia() {
        try {
            List<AdmDivisionPolitica> datos = admin.listarNullOrdenada(AdmDivisionPolitica.class, "admDivisionPolitica", "nombre", true);
            List<SelectItem> items = new ArrayList<>();
            for (AdmDivisionPolitica obj : datos) {
                items.add(new SelectItem(obj, obj.getNombre()));
            }
            return items;
        } catch (Exception e) {
            log.error("getSelectedItemProvincia() {} ", e.getMessage());
        }
        return null;
    }

    public List<SelectItem> getSelectedItemCanton() {
        try {

            List<SelectItem> items = new ArrayList<>();
            for (AdmDivisionPolitica obj : provincia.getAdmDivisionPoliticaList()) {
                items.add(new SelectItem(obj, obj.getNombre()));
            }
            return items;
        } catch (Exception e) {
            log.error("getSelectedItemCanton() {} ", e.getMessage());
        }
        return null;
    }

    public List<SelectItem> getSelectedItemParroquia() {
        try {
            List<SelectItem> items = new ArrayList<>();
            for (AdmDivisionPolitica obj : canton.getAdmDivisionPoliticaList()) {
                items.add(new SelectItem(obj, obj.getNombre()));
            }
            return items;
        } catch (Exception e) {
            log.error("getSelectedItemParroquia() {} ", e.getMessage());
        }
        return null;
    }

    public void duplicarDireccion() {
        try {
            //////////////    hcHistoria.setHcDireccionReferencia(hcHistoria.getHcDireccion().trim());
        } catch (Exception e) {
            log.error("duplicarDireccion() {} ", e.getMessage());
        }

    }

    @Override
    public DataModel<CexConsultaTerapia> getDataModel() {
        return null;
    }

    public CexHistoriaClinica getCexHistoriaClinica() {
        return hcPaciente;
    }

    public void setCexHistoriaClinica(CexHistoriaClinica hcPaciente) {
        this.hcPaciente = hcPaciente;
    }

    public Integer getBusqueda() {
        return busqueda;
    }

    public void setBusqueda(Integer busqueda) {
        this.busqueda = busqueda;
    }

    public Integer getTipoBusqueda() {
        return tipoBusqueda;
    }

    public void setTipoBusqueda(Integer tipoBusqueda) {
        this.tipoBusqueda = tipoBusqueda;
    }

    public String getParametroBusqueda() {
        return parametroBusqueda;
    }

    public void setParametroBusqueda(String parametroBusqueda) {
        this.parametroBusqueda = parametroBusqueda;
    }

    public String getApellidoPbusqueda() {
        return apellidoPbusqueda;
    }

    public void setApellidoPbusqueda(String apellidoPbusqueda) {
        this.apellidoPbusqueda = apellidoPbusqueda;
    }

    public String getApellidoMbusqueda() {
        return apellidoMbusqueda;
    }

    public void setApellidoMbusqueda(String apellidoMbusqueda) {
        this.apellidoMbusqueda = apellidoMbusqueda;
    }

    public String getpnombrebusqueda() {
        return pnombrebusqueda;
    }

    public String getPnombrebusqueda() {
        return pnombrebusqueda;
    }

    public void setPnombrebusqueda(String pnombrebusqueda) {
        this.pnombrebusqueda = pnombrebusqueda;
    }

    public String getSnombrePbusqueda() {
        return snombrePbusqueda;
    }

    public void setSnombrePbusqueda(String snombrePbusqueda) {
        this.snombrePbusqueda = snombrePbusqueda;
    }

    public List<CexHistoriaClinica> getListaHClinica() {
        return listaHClinica;
    }

    public void setListaHClinica(List<CexHistoriaClinica> listaHClinica) {
        this.listaHClinica = listaHClinica;
    }

    public Date getFechaAgenda() {
        return fechaAgenda;
    }

    public void setFechaAgenda(Date fechaAgenda) {
        this.fechaAgenda = fechaAgenda;
    }

    public AdmDivisionPolitica getProvincia() {
        return provincia;
    }

    public void setProvincia(AdmDivisionPolitica provincia) {
        this.provincia = provincia;
    }

    public AdmDivisionPolitica getCanton() {
        return canton;
    }

    public void setCanton(AdmDivisionPolitica canton) {
        this.canton = canton;
    }

    public AdmDivisionPolitica getParroquia() {
        return parroquia;
    }

    public void setParroquia(AdmDivisionPolitica parroquia) {
        this.parroquia = parroquia;
    }

    public Boolean getHabilitar() {
        return habilitar;
    }

    public void setHabilitar(Boolean habilitar) {
        this.habilitar = habilitar;
    }

    public boolean isActivo() {
        return activo;
    }

    public void setActivo(boolean activo) {
        this.activo = activo;
    }

    public boolean isIsextra() {
        return isextra;
    }

    public void setIsextra(boolean isextra) {
        this.isextra = isextra;
    }

    public List<CexAgenda> getListaHistorialTurnos() {
        return listaHistorialTurnos;
    }

    public void setListaHistorialTurnos(List<CexAgenda> listaHistorialTurnos) {
        this.listaHistorialTurnos = listaHistorialTurnos;
    }

    public Integer getTurnosManiana() {
        return turnosManiana;
    }

    public void setTurnosManiana(Integer turnosManiana) {
        this.turnosManiana = turnosManiana;
    }

    public Integer getTurnsTarde() {
        return turnsTarde;
    }

    public void setTurnsTarde(Integer turnsTarde) {
        this.turnsTarde = turnsTarde;
    }

    public boolean isIsGrabar() {
        return isGrabar;
    }

    public void setIsGrabar(boolean isGrabar) {
        this.isGrabar = isGrabar;
    }

    public AdmUsuario getAdmUsuario() {
        return admUsuario;
    }

    public void setAdmUsuario(AdmUsuario admUsuario) {
        this.admUsuario = admUsuario;
    }

    public Date getFechaFin() {
        return fechaFin;
    }

    public void setFechaFin(Date fechaFin) {
        this.fechaFin = fechaFin;
    }

    public List<CexDia> getListaDia() {
        return listaDia;
    }

    public void setListaDia(List<CexDia> listaDia) {
        this.listaDia = listaDia;
    }

    public String getMotivoBloqueo() {
        return motivoBloqueo;
    }

    public void setMotivoBloqueo(String motivoBloqueo) {
        this.motivoBloqueo = motivoBloqueo;
    }

    public Date getHoraTurnoExtra() {
        return horaTurnoExtra;
    }

    public void setHoraTurnoExtra(Date horaTurnoExtra) {
        this.horaTurnoExtra = horaTurnoExtra;
    }

    public String getMotivoCancelar() {
        return motivoCancelar;
    }

    public void setMotivoCancelar(String motivoCancelar) {
        this.motivoCancelar = motivoCancelar;
    }

    public UsuarioAdmin getUser() {
        return user;
    }

    public void setUser(UsuarioAdmin user) {
        this.user = user;
    }

    public CexTipoTerapia getCexTipoTerapia() {
        return cexTipoTerapia;
    }

    public void setCexTipoTerapia(CexTipoTerapia cexTipoTerapia) {
        this.cexTipoTerapia = cexTipoTerapia;
    }

    public int getNumeroSesiones() {
        return numeroSesiones;
    }

    public void setNumeroSesiones(int numeroSesiones) {
        this.numeroSesiones = numeroSesiones;
    }

    public int getTotalConsulta() {
        return totalConsulta;
    }

    public void setTotalConsulta(int totalConsulta) {
        this.totalConsulta = totalConsulta;
    }

    public List<CexConsulta> getListaConsulta() {
        return listaConsulta;
    }

    public void setListaConsulta(List<CexConsulta> listaConsulta) {
        this.listaConsulta = listaConsulta;
    }

    public List<CexConsultaTerapia> getListaDiaria() {
        return listaDiaria;
    }

    public void setListaDiaria(List<CexConsultaTerapia> listaDiaria) {
        this.listaDiaria = listaDiaria;
    }

    public List<CexConsultaTerapia> getListaAgeTemp() {
        return listaAgeTemp;
    }

    public void setListaAgeTemp(List<CexConsultaTerapia> listaAgeTemp) {
        this.listaAgeTemp = listaAgeTemp;
    }

    @Override
    protected ResourceBundle getProperties() {
        return ResourceBundle.getBundle("aplicacion");
    }
}
